home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / 3D QuickTime Dynamics / kSan Sources / kSanAGWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-24  |  19.8 KB  |  604 lines
  1. #include "kSanAGWindow.h"
  2. #include "kSanSharedUtils.h"
  3. #include "OHApplicationPublic.h"
  4. #include "OHCursor.h"
  5. #include "OHMenu.h"
  6. #include "OHPictButton.h"
  7. #include "OHMultipleViews.h"
  8. #include "OHScrollableView.h"
  9.  
  10. void    toggleShowBonds (OHWindow * wp);
  11. short AGWinClose (AGWindow *ag);
  12. void AGWinDoNull(OHWindow *wp);
  13.  
  14. void AGWinDoKeyDown(OHWindow *wp, char theChar);
  15. short AGWindowDoMessage (KozoDispatchStack *ds, doMessageMethodArgs *dmma);
  16. short AGWindowHandleReport (KozoDispatchStack *ds, reportMethodArgs *rd);
  17. void AGWindowIdle(AGWindow *gw, EventRecord *event);
  18. short AGWinAddControlsCompletionProc(KozoDispatchStack *ds, constructorMethodArgs *cma, AGWindow *ag);
  19.  short addAGButton(AGWindow *gw, short resID, short nowVisible, ProcPtr func, Rect *theRect, kozoObject **butt);
  20. void setOptionKeyToggleButtons(AGWindow *gw);
  21.  
  22. void    AGWinHandleMenuChoice    (AGWindow * gw, short item);
  23. short AGWindowActivate(AGWindow *gw);
  24. short AGWindowDeactivate(AGWindow *gw);
  25. void initVectorsAndVertices(void);
  26. void initCellManip(AGWindow *gw);
  27. void    AGWindowDoMouseModeSwitch    (AGWindow*ag);
  28. short AGWindowDoMouseMoved ( AGWindow *ag);
  29. //void AGWindowSetWindowCenter(kozoObject *agObj,AGWindow *ag);
  30. void AGWindowDoShowBondsSwitch    (AGWindow *ag);
  31.  
  32.  
  33. //kozoObject *agMenu;
  34.    LinePair gCubeEdges[NUMCUBEEDGES];
  35.    kSanVector gCubeVerticies[NUMCUBEVERTICES];
  36.  
  37. short initClassAGWindow(void)
  38. {
  39.     short err = noErr;
  40.     kozoClass *newClass;
  41.     kozoObject *co;
  42.  
  43.     newClass = addClass(&co,ClassAGWindow,  ClassView, sizeof (AGWindow), "atom graphics window");
  44.     if (newClass)
  45.     {
  46.         err =    setFuncs(newClass, 0L,  AGWindowConstructor,
  47.               AGWindowDestructor, AGWindowGetData, AGWindowSetData, AGWindowDoMessage,
  48.               AGWindowHandleReport, nilCountFunc, nilResolveFunc, nilCreateElementFunc);
  49.         OHViewSetViewFuncs (newClass, AGWindowDraw, AGWindowDoKey, AGWindowDoClick, AGWindowFindObject, nilPointer);
  50.         addInheritance(newClass, ClassScrollableView);
  51.         addInheritance(newClass, ClassFilmableView);
  52.         addInheritance(newClass, ClassPane);
  53.         addInheritance(newClass, ClassMultipleViews);
  54.         addInheritance(newClass, ClassWindow);
  55.         initVectorsAndVertices();
  56.         
  57.          err =  kozoClassAddRemove4ItemsToSave(newClass, true, pMagnification ,pPerspective ,pParticleSize ,pBondsVisible);   
  58.          err =  kozoClassAddRemove4ItemsToSave(newClass, true, pShadeMethod, pSizeMethod , pShadeRange ,pShadeEven );   
  59.          err =  kozoClassAddRemove3ItemsToSave(newClass, true, pParticleSizeFactor , pViewMatrix,  pAGParticleList );   
  60.      }   // note:  pColourMethodObj means get an kozoObject ptr:   kozo should be smart enought to make sure the object is actually saved
  61.     return (err); 
  62. }
  63.  
  64. void initAGMenu(kozoObject *mBarObj)
  65. {
  66.     short err = noErr;
  67.       char  initName[10] = "Graphics";
  68.      kozoObject *agMenu = nilPointer;
  69.      kozoObject *newItem = nilPointer;
  70.   
  71.     kozoNew2DataPtrs(&agMenu, ClassMenu, mBarObj, 
  72.                             pName, typeChar, initName, strlen(initName),
  73.                             pEnabled, typeFalse, nilPointer, 0L);
  74.     
  75.        OHStoreUniqueReference(agMenu, globalAppObject, mAGWindowMenu);
  76.  
  77.     newItem =  kSanMenuItemAllocateWithThreeArgs(agMenu, (ProcPtr) messageForFrontWindow, kDoDialogMessage, typeNull, nilPointer, "Settings...");
  78.     newItem =  kSanMenuItemAllocateWithThreeArgs(agMenu, (ProcPtr) messageForFrontWindow, kAGWindowMouseFunctionToggle, typeNull,nilPointer, "Mouse Manipulation");
  79.      OHStoreUniqueReference(newItem, globalAppObject, iMouseModeMenuItem);
  80.     newItem =  kSanMenuItemAllocateWithThreeArgs(agMenu, (ProcPtr) messageForFrontWindow, kAGWindowShowBondsToggle, typeNull,nilPointer, "Bond Visibility");
  81.      OHStoreUniqueReference(newItem, globalAppObject, iBondsMenuItem);
  82.     newItem =  kSanMenuItemAllocateWithThreeArgs(agMenu, (ProcPtr) messageForFrontWindow, kAGWindowDefaultView,typeNull, nilPointer, "Default View");
  83.  
  84. }
  85.  
  86. void setCubeEdge(LinePair*edge, short start, short end, short colour);
  87. void setCubeEdge(LinePair*edge, short start, short end, short colour)
  88. {
  89.     edge->start = start;
  90.     edge->end = end;
  91.     edge->colour = colour;
  92. }
  93.  
  94. void initVectorsAndVertices(void)
  95. {
  96.  
  97. #ifndef __2DVectors__
  98.     setkSanVectorD (&gCubeVerticies[0],  0.5,  0.5,  0.5 );
  99.     setkSanVectorD (&gCubeVerticies[1],  0.5,  0.5, -0.5 );
  100.     setkSanVectorD (&gCubeVerticies[2],  0.5, -0.5,  0.5 );
  101.     setkSanVectorD (&gCubeVerticies[3],  0.5, -0.5, -0.5 );
  102.     setkSanVectorD (&gCubeVerticies[4], -0.5,  0.5,  0.5 );
  103.     setkSanVectorD (&gCubeVerticies[5], -0.5,  0.5, -0.5 );
  104.     setkSanVectorD (&gCubeVerticies[6], -0.5, -0.5,  0.5 );
  105.     setkSanVectorD (&gCubeVerticies[7], -0.5, -0.5, -0.5 );
  106. #else
  107.     setkSanVectorD (&gCubeVerticies[0],  0.5,  0.5, 0 );
  108.     setkSanVectorD (&gCubeVerticies[1],  0.5, -0.5, 0 );
  109.     setkSanVectorD (&gCubeVerticies[2], -0.5,  0.5, 0 );
  110.     setkSanVectorD (&gCubeVerticies[3], -0.5, -0.5, 0 );
  111. #endif
  112.  
  113. #ifndef __2DVectors__
  114.     setCubeEdge(&gCubeEdges[0], 0,1,kLinePairBlackColour);
  115.     setCubeEdge(&gCubeEdges[1], 0,2,kLinePairBlackColour);
  116.     setCubeEdge(&gCubeEdges[2], 0,4,kLinePairBlackColour);
  117.     setCubeEdge(&gCubeEdges[3], 1,3,kLinePairBlackColour);
  118.     setCubeEdge(&gCubeEdges[4], 1,5,kLinePairBlackColour);
  119.     setCubeEdge(&gCubeEdges[5], 2,3,kLinePairBlackColour);
  120.     setCubeEdge(&gCubeEdges[6], 2,6,kLinePairBlackColour);
  121.     setCubeEdge(&gCubeEdges[7], 3,7,kLinePairRedColour);
  122.     setCubeEdge(&gCubeEdges[8], 4,5,kLinePairBlackColour);
  123.     setCubeEdge(&gCubeEdges[9], 4,6,kLinePairBlackColour);
  124.     setCubeEdge(&gCubeEdges[10], 5,7,kLinePairGreenColour);
  125.     setCubeEdge(&gCubeEdges[11], 6,7,kLinePairBlueColour);
  126. #else
  127.     setCubeEdge(&gCubeEdges[0], 0,1,kLinePairBlackColour);
  128.     setCubeEdge(&gCubeEdges[1], 0,2,kLinePairBlackColour);
  129.      setCubeEdge(&gCubeEdges[2], 1,3,kLinePairRedColour);
  130.      setCubeEdge(&gCubeEdges[3], 2,3,kLinePairGreenColour);    
  131. #endif
  132. }
  133.  
  134. void initCellManip(AGWindow *gw)
  135. {
  136.     gw->manip.latRotateAngle = 2.0;
  137.     gw->manip.longRotateAngle = 2.0;
  138.     gw->manip.axialRotateAngle = 2.0;
  139.     gw->manip.horizShift = 0.5;
  140.     gw->manip.vertShift = 0.5;
  141.     gw->manip.hikiShift = 0.5;
  142. }
  143.  
  144. short AGWindowConstructor(KozoDispatchStack *ds, constructorMethodArgs *cma)
  145. {
  146.     short err = noErr;
  147.     char beingUnflattened = false;
  148.     float halfFloat = 0.5;
  149.     DescType classToDraw = ClassButton;
  150.     Rect r = {-1000, -1000, +1000, +1000};
  151.     AGWindow *gw = (AGWindow *) ds->thisPD;
  152.     
  153.      insertParam (cma->initialData, pBounds, typeQDRectangle, &r, sizeof(Rect));
  154.     extractParam (ds, cma->initialData, pVisibleBounds, typeQDRectangle, &r, sizeof(Rect));
  155.     insertParam (cma->initialData, pMVClassToDraw, typeType, &classToDraw, sizeof(DescType));
  156.     insertParam (cma->initialData, pHorizontalFractionScrolled, typeShortFloat, &halfFloat, sizeof(float));
  157.     insertParam (cma->initialData, pVerticalFractionScrolled, typeShortFloat, &halfFloat, sizeof(float));
  158.  
  159.     if (! AERecordHasKey(cma->initialData, pAGParticleList) ) insertParam (cma->initialData, pIncludeAllParticles, typeTrue, nilPointer, 0L);
  160.     
  161.     extractParam (ds, cma->initialData, pBeingUnflattened, typeBoolean, &beingUnflattened, sizeof(char)) ;
  162.     err = dispatchLoop(ds, cma);
  163.     if (!err)
  164.     {
  165.         gw->win = KDSGetPrivateData(ds, ClassWindow);
  166.         gw->mode = kSelectAndHighlightMode;
  167.         gw->doColourCalc = true;
  168.         initCellManip(gw);
  169.         AGDefaultView(&gw->windowView);
  170.  
  171.         AGSetSizeMethod (gw, kSizeByWindow);
  172.         AGSetShadeMethod (gw, kNoShade);
  173.         
  174.         gw->cpi = nilPointer;
  175.         gw->sim = simData (cma->container);
  176.         if (!beingUnflattened) AGSetColourMethodMenuChoice(gw, 1);
  177.         err = VSListInitialize(&gw->grafDataList, sizeof(grafData));
  178.         //gw->grafDataHandle = NewHandle(0);  // a grafData structure
  179.         //gw->grafLockCount = 0;
  180.     }
  181.      initializeList(&gw->orderList);    
  182.      initializeList(&gw->particleList);
  183.      BitListInitialize(&gw->partBits);
  184.     KDSAddCompletionProc(ds, AGWinAddControlsCompletionProc, gw);
  185.      KDSReturnError(ds, err);
  186. }
  187.  
  188.  
  189.  
  190. short AGWindowDestructor (KozoDispatchStack *ds, destructorMethodArgs* dma)
  191. {
  192. #pragma unused(dma)
  193.     AGWindow *gw = (AGWindow *) ds->thisPD;
  194.      AGWinInstallModule (gw, ClassColourPlugIn, nilPointer);
  195.  
  196.     BitListDispose(&gw->partBits);
  197.     VSListDispose(&gw->grafDataList);
  198.     disposeList(&gw->orderList );
  199.     disposeList(&gw->particleList);
  200.     KDSReturnContinue(ds);
  201. }
  202.  
  203.  
  204.  
  205. short AGWindowDoMouseMoved ( AGWindow *ag)
  206. {
  207.     short err = noErr;
  208.      char unused;
  209.     char useArrow = false;
  210.    #pragma unused(unused)
  211.     RgnHandle rgn = NewRgn();
  212.     RgnHandle circleRgn = NewRgn();
  213.     OHBufferedView *bv = kozoObjectGetPrivateData (ag->win->obj, ClassBufferedView);
  214.     kozoObject *newCursorObj = nilPointer;
  215.     Point zeroPoint = {0,0};
  216.     Point localPoint;
  217.     
  218.     GetMouse (&localPoint);
  219.     LocalToGlobal (&zeroPoint);
  220.  
  221.     if (ag->mode == kSelectAndHighlightMode)
  222.     {
  223.         if (PtInRect(localPoint, &( bv->world->portRect))) 
  224.          {
  225.              newCursorObj = OHGetNamedReference(globalAppObject, kFingerCursor);
  226.              RectRgn(rgn, &bv->world->portRect );
  227.              // now subtract the circle region
  228.              DiffRgn(rgn, circleRgn, rgn);
  229.          }
  230.          else
  231.          {
  232.               useArrow = true;
  233.          }
  234.     }
  235.     else
  236.     {
  237.          AGWindowSetDragActiveRegion( ag,  circleRgn);
  238.          if (PtInRgn ( localPoint, circleRgn)) 
  239.          {
  240.              newCursorObj = OHGetNamedReference(globalAppObject, kRotateCursor);
  241.             CopyRgn(circleRgn,  rgn);
  242.          }
  243.          else if (PtInRect(localPoint, &( bv->world->portRect))) 
  244.          {
  245.              newCursorObj = OHGetNamedReference(globalAppObject, kSpinCursor);
  246.              RectRgn(rgn, &bv->world->portRect );
  247.              // now subtract the circle region
  248.              DiffRgn(rgn, circleRgn, rgn);
  249.          }
  250.          else
  251.          {
  252.               useArrow = true;
  253.          }
  254.     }
  255.     
  256.     
  257.     if (useArrow)
  258.     {
  259.         Rect r;
  260.         OHSetRect (&r, localPoint.h, localPoint.v,localPoint.h + 1, localPoint.v + 1); 
  261.         RectRgn(rgn, &r);
  262.         newCursorObj = OHGetNamedReference(globalAppObject, kArrowCursor);
  263.     }
  264.     dispatchNilMessage (newCursorObj , kSetCursorMessage);
  265.     
  266.     if (rgn) OffsetRgn(rgn,zeroPoint.h,zeroPoint.v);
  267.     setAppMouseRegion (rgn);
  268.     DisposeRgn(rgn);
  269.     DisposeRgn(circleRgn);
  270.     return(err);
  271. }
  272.  
  273.  
  274.  
  275. short AGWinDoRotateEvent(AGWindow *ag,  AEMessageData *md);
  276. short AGWinDoRotateEvent(AGWindow *ag,  AEMessageData *md)
  277. {
  278.     short err = noErr;
  279.     AEDesc     data = gNilDesc;
  280.     AEDesc trixDesc = gNilDesc;
  281.     DescType actualType;
  282.     long actualSize;
  283.      float horiz = 0;
  284.     float vert = 0;
  285.     float axial = 0;
  286.     kSanMatrix trix;    
  287.     
  288.      AEGetParamPtr( md->event, keyHorizontalRotation, typeShortFloat, &actualType, &horiz, sizeof(float), &actualSize );
  289.      AEGetParamPtr( md->event, keyVerticalRotation,   typeShortFloat, &actualType, &vert,  sizeof(float), &actualSize );
  290.      AEGetParamPtr( md->event, keyAxialRotation,      typeShortFloat, &actualType, &axial, sizeof(float), &actualSize );
  291.     horiz *= -1.0;
  292.     trix = ag->windowView.viewMatrix;
  293.     Spin3dMatrixInDegreesD(&trix, horiz, vert, axial);
  294.     
  295.     make3dMatrixDescD(&trix, &trixDesc   );
  296.     kozoSetData(ag->win->obj, pViewMatrix,  &trixDesc);
  297.     AEDisposeDesc(&trixDesc);
  298.     
  299.      return (err); 
  300. } 
  301. short AGWindowDoMessage (KozoDispatchStack *ds, doMessageMethodArgs *dmma)
  302. {
  303.     short err = noErr;
  304.     AGWindow *ag = (AGWindow *) ds->thisPD;
  305.     switch (dmma->message)
  306.     {
  307.         case kRotateMessage:
  308.              err = AGWinDoRotateEvent(ag, (AEMessageData *) dmma->data);
  309.             break;
  310.         case kAGWindowSettingsDialog :
  311.         case kDoDialogMessage:
  312.             AGWinDoDialog(ag);
  313.             break; 
  314.          case kAGWindowShowBondsToggle  :
  315.             AGWindowDoShowBondsSwitch(ag);
  316.             break; 
  317.          case kAGWindowDefaultView :
  318.             // dialogResult = doAShortDialog(kSetViewDialogResID, nilPointer);
  319.             break; 
  320.           case kAGWindowMouseFunctionToggle  :
  321.              AGWindowDoMouseModeSwitch(ag);
  322.             break; 
  323.           case kMouseMovedMessage  :
  324.               AGWindowDoMouseMoved(  ag);
  325.             goto Default;
  326.         case kActivateMessage:
  327.                 // set the mouseRegion to a small rect so we'll get a mouse moved event 
  328.             {
  329.                  RgnHandle noRgn = NewRgn();
  330.                 setAppMouseRegion (noRgn);
  331.                 DisposeRgn(noRgn);
  332.             }
  333.             goto Default;
  334.         case kDeactivateMessage:
  335.             {
  336.                 AEDesc activeDesc = {typeTrue, nilPointer};
  337.  
  338.                 if (dmma->message == kDeactivateMessage)  activeDesc.descriptorType = typeFalse;
  339.  
  340.                  err = kozoSetData(OHGetNamedReference(globalAppObject, mAGWindowMenu), pEnabled, &activeDesc);  
  341.              }
  342.             goto Default; 
  343.          case kControlValueChangedMessage:
  344.             break; 
  345.         case  kNullEventMessage:   // not an idle message
  346.             AGWindowIdle( ag, (EventRecord *) dmma->data);
  347.             break;
  348.         case kSetMouseModeButtonsMessage:
  349.             SetAllMouseModeButtons(ag);
  350.             break;
  351.     //    case kGetSimulationPtrMessage:
  352.     //        if (gw->sim) (* ((kSanSimulation **)dmma->data)) = gw->sim;
  353.     //        else   err = OHErrNullObject;
  354.     //        break;
  355.         case  kInitializeWindowOrderListMessage :
  356.              break;
  357.         case kChangeParticleIndexMessage:
  358.              AGWindowChangeParticleIndex( ag,  ((long  *)dmma->data)[0], ((long  *)dmma->data)[1]);
  359.              break;
  360.         case kRemoveParticleListMessage:
  361.             AGWindowRemoveParticleList( ag, (OHList *) dmma->data);
  362.              break;
  363.         case kRemoveParticleMessage:
  364.             AGWindowRemoveParticle( ag, (long) dmma->data);
  365.             break;
  366.          case kAddParticleListMessage :
  367.              err =  AGWindowAddParticleList ( ag,  (OHList *)dmma->data);
  368.             break;
  369.         case kAddParticleMessage :    
  370.             err =  AGWindowAddToPartList( ag, (long) dmma->data);
  371.             break;
  372.         case kUnflattenFinishedMessage:
  373.             err = dispatchLoop(ds, dmma);
  374.             {
  375.                 kozoObject *aPlugIn = OHGetNamedReference(ds->obj, ClassColourPlugIn);
  376.                 
  377.                    if (!aPlugIn)  aPlugIn = kozoObjectGetNthItemOfClassX(ds->obj, ClassColourPlugIn, 0);
  378.                    
  379.                  if (aPlugIn) 
  380.                 {
  381.                     err = AGWinInstallModule (ag, ClassColourPlugIn, aPlugIn);
  382.                 }
  383.                 else
  384.                 { 
  385.                     AGSetColourMethodMenuChoice(ag, 1);
  386.                   }
  387.               }
  388.             goto Default;
  389.         case kCopyMessage:
  390.              err = dispatchLoop(ds, dmma);
  391.         case kCutMessage:
  392.         case kPasteMessage:
  393.         case kClearMessage: // send the message to the simulation
  394.             if (!err) err = forwardMessage (simOBJ(ag->sim),  dmma);
  395.             break;
  396.         Default:
  397.         default:
  398.             KDSReturnContinue(ds);
  399.             break;
  400.     }
  401.     KDSDoneDispatch(ds);
  402.     KDSReturnError(ds, err);
  403. }
  404.  
  405. short AGWindowHandleReport (KozoDispatchStack *ds, reportMethodArgs *rd)
  406. {
  407.     short err = noErr;
  408.     short shouldContinue = true;
  409.     AGWindow *gw = (AGWindow *) ds->thisPD;
  410.     
  411.      switch (rd->functionForContainer)
  412.     {
  413.         case fDoMessage:
  414.             switch (rd->args.dmma.message)
  415.             {
  416. //                 case  kGetSimulationPtrReport:   
  417. //                    AGWindowDoMessage(ds, &rd->args.dmma);
  418. //                    shouldContinue = false;
  419. //                    break;
  420.             }
  421.             break;
  422.     }
  423.     if (!shouldContinue) KDSDoneDispatch(ds);
  424.     KDSReturnError(ds, err);
  425. }
  426. void AGWindowIdle( AGWindow *gw, EventRecord *event)
  427. {    
  428.  #pragma unused(event)
  429.  
  430.      setOptionKeyToggleButtons( gw);
  431.     // AGWindowMaintainCursor(ag);
  432. }
  433.  
  434. short AGWinAddControlsCompletionProc(KozoDispatchStack *ds, constructorMethodArgs *cma, AGWindow *ag)
  435. {    
  436. #pragma unused(cma)
  437.     short err = noErr;
  438.     short scrollInset = 68;
  439.     kozoObject *butt;
  440.     Rect r;
  441.  
  442.     if (!err) err = kozoGetDataPtr ( ds->obj, pBounds, typeQDRectangle, &r, sizeof(Rect));
  443.     r.bottom = OHRectHeight(&r) + 1;
  444.     r.top = r.bottom - 16;
  445.     r.left = 0;
  446.     r.right = r.left + 17;
  447.  
  448.     if (!err) err = kozoSetDataPtr ( ds->obj, pScrollLeftInset, typeShortInteger, &scrollInset, sizeof(short));
  449.     addAGButton( ag,  kMagnifyPictResID, true,  (ProcPtr) magnifyButtonProc,  &r, &butt);
  450.     addAGButton( ag,  kUnmagnifyPictResID,false ,  (ProcPtr) unmagnifyButtonProc,  &r, &butt);
  451.  
  452.     r.left = r.right;
  453.     r.right = r.left + 17;
  454.     addAGButton(ag,  kCloserPictResID, true, (ProcPtr) closerButtonProc,  &r, &butt );
  455.     addAGButton( ag,  kFurtherPictResID, false , (ProcPtr) furtherButtonProc,  &r, &butt);
  456.  
  457.     r.left = r.right;
  458.     r.right = r.left + 17;
  459.     addAGButton( ag,  kLargeBallPictResID, true , (ProcPtr) largerButtonProc,  &r, &butt);
  460.     addAGButton( ag,  kSmallBallPictResID, false , (ProcPtr) smallerButtonProc,  &r, &butt);
  461.  
  462.     r.left = r.right;
  463.     r.right = r.left + 17;
  464.     addAGButton( ag,  kRollCellPictResID, true , (ProcPtr) rollCellButtonProc,  &r, &butt);
  465.     OHStoreUniqueReference(butt, ds->obj, kAGRollCellButton);
  466.  
  467.     addAGButton( ag,  kSelectFingerPictResID, false , (ProcPtr)selectFingerButtonProc,  &r, &butt);
  468.     OHStoreUniqueReference(butt, ds->obj, kAGSelectHighlightButton);
  469.     return (err);
  470. }
  471.  
  472. void setOptionKeyToggleButtons( AGWindow *gw)
  473. {
  474.     short i = 0;
  475.     char optionKeyPressed = 0;
  476.     char unused;
  477. #pragma unused(unused)
  478.     OHList *buttList;
  479.     kozoObject* nthButt;
  480.     
  481.     
  482.     optionKeyPressed = keyIsPressed(kOptionKeyCode);
  483.     if (gw->lastToggle != optionKeyPressed)
  484.     {
  485.         buttList = getListOfObjectsOfClassX (gw->win->obj, ClassButton);
  486.         if (buttList)
  487.         {
  488.             gw->lastToggle = optionKeyPressed;
  489.             for ( i= 0; i < 3; ++i)
  490.             {
  491.                 char val ;
  492.                 nthButt = castTokozoObject(getNthItem (buttList, (2 * i)));  // e.g. magnify button
  493.                 val = (!optionKeyPressed);
  494.                 if (nthButt) packageAndCallSetBool(nthButt, pVisible, val);    
  495.                 nthButt = castTokozoObject(getNthItem (buttList, (1 + (2 * i))));  // e.g. magnify button
  496.                 val = (optionKeyPressed);
  497.                 if (nthButt) packageAndCallSetBool(nthButt, pVisible, val);    
  498.             }
  499.              releaseListOfObjectsOfClassX (gw->win->obj,  ClassButton);
  500.         }
  501.     }
  502. }
  503. void SetAllMouseModeButtons( AGWindow *ag)
  504. {
  505.      kozoObject * butt;
  506.     char val;
  507.     
  508.     val = (ag->mode == kSelectAndHighlightMode);
  509.     butt =  OHGetNamedReference(ag->win->obj, kAGRollCellButton);
  510.     if (butt)  packageAndCallSetBool(butt, pVisible, val);
  511.  
  512.     val = (ag->mode != kSelectAndHighlightMode);
  513.     butt =  OHGetNamedReference(ag->win->obj, kAGSelectHighlightButton);
  514.     if (butt)  packageAndCallSetBool(butt, pVisible, val);
  515.  
  516.     setMenuToSTR( iMouseModeMenuItem, (ag->mode == kMouseManipulationMode ? kSelectAndHighlightStringID : kMouseManipulationStringID) , "\pmouse mode");
  517. }
  518.  
  519.  short addAGButton( AGWindow *gw, short resID, short nowVisible, ProcPtr func, Rect *theRect, kozoObject **butt)
  520. {
  521.     short err = noErr;
  522.     short canSlide =  topMovesWithWindowSize + bottomMovesWithWindowSize;
  523.     short roundSize = 2;
  524.     short bevelVariant = kControlBevelButtonSmallBevelProc;
  525.      char viz  = nowVisible;
  526.     char unused;
  527. #pragma unused(unused)
  528.     long oneArg  = 1L;
  529.      AEDesc pictDesc = {'PICT', nilPointer};
  530.     AEDesc initialData = {typeNull, nilPointer};
  531.      
  532.       *butt = nilPointer;
  533.     err = stuffRecord5Ptrs( &initialData,  pBounds, typeQDRectangle, (Ptr) theRect,  sizeof(Rect),
  534.                                            pVisible, typeBoolean,  (Ptr) &viz,  sizeof(char), 
  535.                                            pPersistent, typeFalse,  nilPointer,  0L, 
  536.                                             pBevelButtonVariant, typeShortInteger, &bevelVariant, sizeof(short),
  537.                                           pPICTRezID, typeShortInteger, (Ptr) &resID, sizeof(short));
  538.                                            
  539.      err = stuffRecord4Ptrs( &initialData,  pProcPtr,  typeProcPtr, (Ptr) &func,  sizeof(long)  ,
  540.                                            pNumArgs,  typeLongInteger, (Ptr) &oneArg,  sizeof(long)  ,
  541.                                            pArgument1,  typeLongInteger, (Ptr) &gw,  sizeof(long)  ,
  542.                                            pSlidability,  typeShortInteger, (Ptr) &canSlide,  sizeof(short) );
  543.     
  544.      if (!err) err = kozoNew(butt, ClassPictButton, gw->win->obj, &initialData);
  545.      AEDisposeDesc (&initialData);
  546.      return (err);
  547. }
  548.  
  549. void    AGWindowDoMouseModeSwitch    ( AGWindow*ag)
  550. {
  551.     if (ag->mode == kSelectAndHighlightMode)
  552.     {
  553.         AGSetMouseMode ( ag, kMouseManipulationMode );
  554.     }
  555.     else if (ag->mode == kMouseManipulationMode)
  556.     {
  557.         AGSetMouseMode (  ag, kSelectAndHighlightMode );
  558.     }
  559. }
  560.  
  561.  /*
  562.  
  563. void AGWindowSetWindowCenter(kozoObject *agObj, AGWindow *ag)
  564. {
  565. //    short nowVal, maxVal, wHeight, wWidth;
  566.       Point newCenter = {100, 100};
  567.     wHeight = worldRect.bottom - worldRect.top;
  568.     wWidth = worldRect.right -worldRect.left;
  569.     
  570.     if (gwp->pane.vScroll)
  571.     {
  572.         nowVal = GetControlValue(gwp->pane.vScroll->control.cHandle);
  573.         maxVal = GetControlMaximum(gwp->pane.vScroll->control.cHandle);
  574.         newCenter.v =  (( (maxVal *0.5)- nowVal )  * kMaxWindowHeight / maxVal)   ;
  575.     }
  576.     if (gwp->pane.hScroll)
  577.     {
  578.         nowVal = GetControlValue(gwp->pane.hScroll->control.cHandle);
  579.         maxVal = GetControlMaximum(gwp->pane.hScroll->control.cHandle);
  580.         newCenter.h =    (( (maxVal *0.5) - nowVal) * kMaxWindowWidth / maxVal) ;
  581.     }
  582.     ag->windowView.cellCenter = newCenter;
  583. }
  584.     */
  585. /************  DoShowBondsSwitch   ****************/
  586. void AGWindowDoShowBondsSwitch    ( AGWindow *ag)
  587. {
  588.     AGSetBondsVisible ( ag, ((short)(!(ag->windowView.showBonds))));
  589.     dispatchNilMessage(ag->win->obj, kInvalSelfMessage);
  590. }
  591.  
  592.  
  593. grafData *  AGWindowLockGrafDataC(AGWindow * ag, long *numItems) 
  594. {
  595.     if (ag->grafDataDirty) AGWindowReinitializeGrafDataList(ag);
  596.      return((grafData *)(VSListLockC(&ag->grafDataList, numItems)));
  597. }
  598. grafData *  AGWindowLockGrafData(AGWindow * ag) 
  599. {
  600.     if (ag->grafDataDirty) AGWindowReinitializeGrafDataList(ag);
  601.     return((grafData *)(VSListLock(&ag->grafDataList)));
  602. }
  603.  
  604.